import dayjs from 'dayjs'
import 'dayjs/locale/zh-cn'

// 设置 dayjs 语言为中文
dayjs.locale('zh-cn')

export const UTILUseTimeAgo = (time) => {
    const timeAgo = useTimeAgo(time, {
        messages: {
            justNow: '刚刚',
            past: n => n.match(/\d/) ? `${n}前` : n,
            future: n => n.match(/\d/) ? `${n}后` : n,
            month: '1个月',
            months: n => `${n}个月`,
            year: '1年',
            years: n => `${n}年`,
            day: '1天',
            days: n => `${n}天`,
            hour: '1小时',
            hours: n => `${n}小时`,
            minute: '1分钟',
            minutes: n => `${n}分钟`,
            second: '1秒',
            seconds: n => `${n}秒`,
        },
    })

    return timeAgo.value
}

/**
 * 获取使用年限
 * @param {*} year 
 * @returns 
 */
export const UTILGetDiffYear = (year) => {
    if (!year) return '-'
    const now = dayjs()
    const date = dayjs(year)
    return date.diff(now, 'year')
}

/**
 * 年限相加
*/
export const UTILAddYear = (year, addYear) => {
    const date = dayjs(year)
    return date.add(addYear, 'year').format('YYYY-MM-DD')
}

/**
 * 计算日期是否过期
 * @param {*} date 
 * @returns 
 */
export const UTILIsDateExpired = (date) => {
    const now = dayjs()
    const expiryDate = dayjs(date)
    return expiryDate.isBefore(now)
}

/**
 * 设置文本掩码 掩码数量可配置 开始和结束掩码数量可配置
 * @param {*} text 
 * @param {*} startMaskCount 
 * @param {*} endMaskCount 
 * @returns 
 */
export const UTILSetTextMask = (text, pattern) => {
    // 参数验证
    if (!text || !pattern) {
        return text;
    }

    let result = '';
    let patternIndex = 0;
    let textIndex = 0;

    // 遍历模式字符串
    while (patternIndex < pattern.length && textIndex < text.length) {
        // 获取当前模式字符
        const patternChar = pattern.charAt(patternIndex);

        // 根据不同的模式字符处理
        switch (patternChar) {
            case '#': // 数字
                if (/\d/.test(text[textIndex])) {
                    result += text[textIndex];
                    textIndex++;
                }
                patternIndex++;
                break;

            case '*': // 替换为星号
                result += '*';
                textIndex++;
                patternIndex++;
                break;

            default: // 其他字符直接添加到结果中
                result += patternChar;
                patternIndex++;
                // 如果文本中的字符与模式字符相同，也前进文本索引
                if (text[textIndex] === patternChar) {
                    textIndex++;
                }
        }
    }

    return result;
}

/**
 * 格式化日期
*/
export const UTILFormatDate = (date, format = 'YYYY-MM-DD HH:mm:ss') => {
    if (!date) return '-'
    return dayjs(date).format(format)
}


/**
 * 将扁平数组转换为树形结构
 * @param {Array} items - 扁平数组
 * @param {Object} config - 配置项
 * @param {String} config.id - 唯一标识字段名
 * @param {String} config.pid - 父级标识字段名
 * @param {String} config.children - 子级字段名
 * @returns {Array} - 树形结构数组
 */
export const UTILCemeteryArrayToTree = (items, config = { id: 'id', pid: 'parentId', children: 'children' }) => {
    const result = []; // 存放结果集
    const itemMap = {}; // 存放项的map，用于组装树

    // 先将数组转成map
    for (const item of items) {
        // 根据层级设置显示文本
        let text = '';
        switch (item.treelevel) {
            case 1: // 第一级显示园
                text = item.mwsxy || '';
                break;
            case 2: // 第二级显示区
                text = item.mwsxq || '';
                break;
            case 3: // 第三级显示排
                text = item.mwsxp || '';
                break;
        }
        itemMap[item[config.id]] = {
            ...item,
            text, // 添加显示文本
            value: item[config.id], // 添加值字段
            [config.children]: [],
        };
    }

    // 组装树结构保持不变
    for (const item of items) {
        const id = item[config.id];
        const pid = item[config.pid];
        const treeItem = itemMap[id];

        if (pid === 0 || pid === null || pid === undefined) {
            result.push(treeItem);
        } else {
            if (itemMap[pid]) {
                itemMap[pid][config.children].push(treeItem);
            }
        }
    }

    return result;
};


/**
 * 验证手机号码 
*/
export const UTILValidatePhone = (phone) => {
    let p = /^(?:(?:\+|00)86)?1(?:3\d|4[5-79]|5[0-35-9]|6[1-9]|7[0-8]|8\d|9[0-35-9])\d{8}$/;
    return p.test(phone)
}

